home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1998 / MacHack 1998.toast / Papers / C++ Exceptions / µShell / Core Utilities / LocationInCode.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-02  |  5.6 KB  |  331 lines  |  [TEXT/CWIE]
  1. #ifndef __LOCATIONINCODE__
  2. #define __LOCATIONINCODE__
  3. #pragma once 
  4.  
  5. #ifndef __ERRORS__
  6. #include <Errors.h>
  7. #endif
  8.  
  9. //------------------------------------------------------------------------------
  10.  
  11. class LocationInCode
  12. {
  13. public:
  14.     long    fLineNum;    // Line number where error occurred
  15.     char*    fFileName;    // File where error occurred
  16.                         // (note that __FILE__ evaluates to a global pointer)
  17.  
  18.     LocationInCode(
  19.         long lineNum    = 0,
  20.         char* fileName    = nil)
  21.     :
  22.         fLineNum(lineNum),
  23.         fFileName(fileName)
  24.     {
  25.     }
  26.     
  27.     void AppendToString(Str255& str)                                    const;
  28.  
  29.     void ThrowAEErr(
  30.             OSStatus                err,
  31.             const char*                format, ...)                        const;
  32.     void Throw(
  33.             OSStatus                err)                                const;
  34.     void Throw(
  35.             OSStatus                err,
  36.             AEDesc*                    params)                                const;
  37.     void Throw(
  38.             OSStatus                err,        // an error message
  39.             long                    message,    // MacApp message
  40.             AEKeyword                parameter,
  41.             DescType                paramType,
  42.             const void*                paramData,
  43.             Size                    paramSize)                            const;
  44.  
  45.     void ThrowTypeError(
  46.             OSStatus                err,
  47.             DescType                expectedType)                        const;
  48.     void ThrowKeywordError(
  49.             OSStatus                err,            //
  50.             DescType                expectedType,    // In case of coercion failure, etc.
  51.             const AEDesc&            desc,            // Where we were gitting data from
  52.             AEKeyword                key = 0)                            const;
  53.  
  54.     void ThrowNILResource() const;
  55.     void ThrowNILResource(
  56.             ResType                    type,
  57.             short                    resID)                                const;
  58.  
  59.     OSStatus LogError(
  60.             OSStatus                err)                                const;
  61.     OSStatus LogError(
  62.             OSStatus                err,            
  63.             const char*                message)                            const;
  64.  
  65.     void Failure(
  66.             OSStatus                err,
  67.             long                    message)                            const;
  68.  
  69.     bool    DelegateAECall()                                            const;
  70.  
  71.     void    UserCanceled()
  72.     {
  73.         Throw(userCanceledErr);
  74.     }
  75.  
  76.     void    Failure(OSStatus err, long /*message*/)
  77.     {
  78.         Throw(err);
  79.     }
  80.  
  81.     inline void    FailOSStatus(
  82.         OSStatus                err)                                    const
  83.     {
  84.         if (err != noErr)
  85.         {
  86.             Throw(err);
  87.         }
  88.     }
  89.  
  90.     inline void    FailOSErr(
  91.         OSErr                    err)                                    const
  92.     {
  93.         if (err != noErr)
  94.         {     // CW Seems not to be sign extending w/o cast
  95.             Throw((OSStatus) err);
  96.         }
  97.     }
  98.  
  99.     inline void    FailNIL(
  100.         const void*                ptr,
  101.         OSErr                    err = ePointerNil)                        const
  102.     {
  103.         if (ptr == nil)
  104.         {
  105.             Throw(err);
  106.         }
  107.     }
  108.  
  109.     inline void    FailNILResource(
  110.         const void*                ptr)                                    const
  111.     {
  112.         if (ptr == nil)
  113.         {
  114.             ThrowNILResource();
  115.         }
  116.     }
  117.  
  118.     inline void    FailNILResource(
  119.         const void*                ptr,
  120.         OSType                    resType,
  121.         short                    resID)                                    const
  122.     {
  123.         if (ptr == nil)
  124.         {
  125.             ThrowNILResource(resType, resID);
  126.         }
  127.     }
  128.  
  129.     inline bool ExpectedError(
  130.         OSStatus                returnTrue,
  131.         OSStatus                returnFalse,
  132.         OSStatus                error)                                    const
  133.     {
  134.         if (error == returnTrue)
  135.         {
  136.             return true;
  137.         }
  138.         else
  139.         {
  140.             if (error != returnFalse)
  141.             {
  142.                 Throw(error);
  143.             }
  144.             return false;
  145.         }
  146.     }
  147.  
  148.     inline OSStatus    FailQDErr(
  149.         OSStatus                err)                                    const
  150.     {
  151.         if (err < 0)
  152.         {
  153.             Throw(err);
  154.         }
  155.  
  156.         return err;
  157.     }
  158.  
  159.     inline void    FailAEResult(
  160.         OSStatus                err,
  161.         DescType                type)                                    const
  162.     {
  163.         if (err != noErr)
  164.         {
  165.             ThrowTypeError(err, type);
  166.         }
  167.     }
  168.  
  169.     inline void    FailAEKeyword(
  170.         OSStatus                err,
  171.         DescType                type,
  172.         const AEDesc&            desc,
  173.         AEKeyword                key = 0)                                const
  174.     {
  175.         if (err != noErr)
  176.         {
  177.             ThrowKeywordError(err, type, desc, key);
  178.         }
  179.     }
  180.  
  181.     inline bool    FailOptionalAEKeyword(
  182.         OSStatus                err,
  183.         DescType                type,
  184.         const AEDesc&            desc,
  185.         AEKeyword                key = 0)                                const
  186.     {
  187.         if (err != noErr)
  188.         {
  189.             if (err != errAEDescNotFound)
  190.             {
  191.                 ThrowKeywordError(err, type, desc, key);
  192.             }
  193.         }
  194.  
  195.         return err != 0;
  196.     }
  197.  
  198.     inline OSStatus LogIfErr(
  199.         OSStatus                errnum)                                    const
  200.     {
  201.         if (errnum != noErr)
  202.         {
  203.             LogError(errnum);
  204.         }
  205.  
  206.         return errnum;
  207.     }
  208.  
  209.     inline OSStatus LogIfErr(
  210.         OSStatus                errnum,
  211.         const char*                message)                                const
  212.     {
  213.         if (errnum != noErr)
  214.         {
  215.             LogError(errnum, message);
  216.         }
  217.  
  218.         return errnum;
  219.     }
  220.     
  221.     inline OSStatus LogIfNotErr(
  222.         OSStatus                errnum,
  223.         OSStatus                expected)                                const
  224.     {
  225.         if (errnum != expected)
  226.         {
  227.             LogError(errnum);
  228.         }
  229.  
  230.         return errnum;
  231.     }
  232.  
  233.     inline OSStatus LogIfNotErr(
  234.         OSStatus                errnum,
  235.         OSStatus                expected,
  236.         const char*                message)                                const
  237.     {
  238.         if (errnum != expected)
  239.         {
  240.             LogError(errnum, message);
  241.         }
  242.  
  243.         return errnum;
  244.     }
  245.  
  246.     inline bool ValidatePointer(const void* p)                            const
  247.     {
  248.         return (p != nil) && (((long)(p) & 1) == 0);
  249.     }
  250.     
  251.     inline bool ValidateHandle(const void* h)                            const
  252.     {
  253.         return ValidatePointer(h) && ValidatePointer(* (void**) h);
  254.     }
  255.     
  256.     //
  257.     //
  258.     //
  259.     
  260. #if qDebug
  261.  
  262.     void Warning(const char* message = nil) const;
  263.     void AssertionFailed(const char* message = nil) const;
  264.  
  265. #else
  266.  
  267.     inline void Warning(const char* message = nil) const { message; }
  268.     inline void AssertionFailed(const char* message = nil) const { message; }
  269.  
  270. #endif
  271.  
  272.     inline void WarnIf(bool truth, const char* message = nil)            const 
  273.     {
  274.         if (qDebug && truth)
  275.         {
  276.             Warning(message);
  277.         }
  278.     }
  279.     
  280.     inline void Assert(bool truth, const char* message = nil)            const 
  281.     {
  282.         if (qDebug && !truth)
  283.         {
  284.             AssertionFailed(message);
  285.         }
  286.     }
  287.     
  288.     inline void AssertPtrValid(const void* p, const char* message = nil) const
  289.     {
  290.         if (qDebug)
  291.         {
  292.             Assert(ValidatePointer(p), message);
  293.         }
  294.     }
  295.     
  296.     inline void AssertHandleValid(const void* h, const char* message = nil)    const
  297.     {
  298.         if (qDebug)
  299.         {
  300.             Assert(ValidateHandle(h), message);
  301.         }
  302.     }
  303.  
  304.     //
  305.     //
  306.     //
  307.     
  308.     void RequirementNotMet(const char* message = nil)                    const;
  309.     
  310.     inline void Require(bool truth, const char* message = nil)            const
  311.     {
  312.         if (!truth)
  313.         {
  314.             RequirementNotMet(message);
  315.         }
  316.     }
  317.     
  318.     inline void RequirePtrValid(const void* p, const char* message = nil) const
  319.     {
  320.         Require(ValidatePointer(p), message);
  321.     }
  322.     
  323.     inline void RequireHandleValid(const void* h, const char* message = nil) const
  324.     {
  325.         Require(ValidateHandle(h), message);
  326.     }
  327.     
  328. };
  329.  
  330. #endif // __LOCATIONINCODE__
  331.